//#pragma once
//#include <iostream>
//#include <assert.h>
//
//using namespace std;
//
//namespace WX
//{
//	template <class T>
//	
//		class vector
//	{
//	public:
//
//		typedef T* iterator;
//
//		iterator begin()
//		{
//			return _start;
//		}
//
//		iterator end()
//		{
//			return _finish;
//		}
//
//		vector()
//			:_start(nullptr)
//			, _finish(nullptr)
//			, _end_of_storage(nullptr)
//		{}
//
//		size_t size() const
//		{
//			return _finish - _start;
//		}
//
//		size_t capacity() const
//		{
//			return _end_of_storage - _start;
//		}
//
//		T& operator[](size_t i)
//		{
//			assert(i < size());
//			return _start[i];
//		}
//
//		void reserve(size_t n)
//		{
//			if (n > capacity())
//			{
//				size_t Oldsize = size();
//				T* tmp = new T[n];
//				memcpy(tmp, _start, sizeof(T) * Oldsize);
//				_start = tmp;
//				_finish = _start + Oldsize;
//				_end_of_storage = _start + n;
//			}
//		}
//
//		void push_back(const T& x)
//		{
//			if (_finish == _end_of_storage)
//			{
//				reserve(capacity() == 0 ? 4 : capacity() * 2);
//			}
//			*_finish = x;
//			_finish++;
//		}
//
//		~vector()
//		{
//			delete[] _start;
//			_start = _finish = _end_of_storage = nullptr;
//		}
//
//
//	private:
//		T* _start;
//		T* _finish;
//		T* _end_of_storage;
//	};
//}


#include <iostream>

using namespace std;

namespace WX
{
	template <class T>
	class vector
	{
	public:
		vector()
			:_start(nullptr)
			, _finish(nullptr)
			, _end_of_storage(nullptr)
		{}

		typedef T* iterator;
		typedef const T* const_iterator

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin()
		{
			return _start;
		}

		const_iterator end()
		{
			return _finish;
		}

		size_t size()
		{
			return _finish - _start;
		}

		size_t capacity()
		{
			return _end_of_storage - _start;
		}

		void reserve(size_t n)
		{
			size_t Oldsize = size();
			if (Oldsize < n)
			{
				T* tmp = new T[n];
				memcpy(tmp, _start, sizeof(T) * Oldsize);
				_start = nullptr;
				_start = tmp;
				_finish = _start + Oldsize;
				_end_of_storage = _start + n;
			}
		}

		void push_back(const T& x)
		{
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			*_finish = x;
			 _finish++;
		}

		~vector()
		{
			delete[] _start;
			_finish = nullptr;
			_end_of_storage = nullptr;
		}
	private:
		T* _start;
		T* _finish;
		T* _end_of_storage;
	};

}



